<html>
<script>

    var n = 0;

    // // 计算阶乘的递归函数
    function factorial(x) {
        if (x<= 0) {
            // console.log(1);
            n++;
            return 1;
           
        } else {
            n++;
            console.log(x); 
            return x * factorial(x -1);    
        }
    }
    var b = factorial(3);
    console.log(b)
    console.log(n)

    // 可选参数
    // function getPropertyNames(o,/* optional*/ a) {
    //     console.log(o,a);
    //     if(a === undefined) a = []; // 如果未定义就使用新数组
    //     for (var property in o) { a.push(property); console.log(typeof pro); };
    //     return a;
    // }
    // var b = getPropertyNames([1,2]);
    // console.log(typeof b[0]);

    // // 关于标识符arguments
    // function f(x,y,z) {
    //     console.log(arguments.length);
    //     if(arguments.length !=3){
    //         throw new Error("funtion f called with" + arguments.length + 
    //         "argunments, but it expects 3 arguments");
    //     }
    //     //在执行函数的其他逻辑
    //     else{
    //         console.log("传参数目正确")
    //     }


    // }

    // f([1,2],1);


    // function max(a,b,c/* ...*/) {
    //     var max = Number.NEGATIVE_INFINITY;
    //     console.log("argunments", arguments)
    //     for (let i = 0; i < arguments.length; i++) {
    //         console.log("循环一次",max);
    //         if (arguments[i] > max) {
    //             max = arguments[i];
    //             // 返回最大值
    //             console.log("循环一次",max);
    //         }

    //     }
    //     return max;
    // }

    // var b = max(1,2,5);
    // console.log("参数", b);

    // callee 和 caller 例子

    // function f(x) {
    //     if (x <= 1) return 1;
    //     return x * arguments.callee(x - 1)
    // }
    // var factorial = f(10);
    // console.log("打印", factorial);

    // function sum(a) {
    //     console.log(isArrayLike(a))
    //     if (isArrayLike(a)) {
    //         // console.log(isArrayLike(a))
    //     }

    // }
    // function isArrayLike(o) {
    //     if (o &&                                // o is not null, undefined, etc.
    //         typeof o === 'object' &&            // o is an object
    //         isFinite(o.length) &&               // o.length is a finite number
    //         o.length >= 0 &&                    // o.length is non-negative
    //         o.length === Math.floor(o.length) &&  // o.length is an integer
    //         o.length < 4294967296)              // o.length < 2^32
    //         return true;                        // Then o is array-like
    //     else
    //         return false;                       // Otherwise it is not
    // }
    // sum(1);

    // 作为值的函数
    // function square(x) {
    //     return x*x;
    // }

    // var s = square;
    // console.log(s);
    // // square(4);
    // console.log(square(4));
    // s(4);
    // console.log(s(4));

    // // 当函数作为对象的属性调用时,函数就称为方法
    // var o = {square: function(x){return x*x}}; // 对象直接量
    // var y = o.square(6);
    // // console.log(y);

    // // 当函数作为数组的属性调用时
    // var a = [function(x){ return x*x},10]
    // console.log(a[0](20))




    // // 将函数用作值
    // // 在这里定义一些简单的函数
    // function add(x,y) {return x +y;}
    // function subtract(x,y) {return x - y;}
    // function multiply(x,y) {return x * y;}
    // function divide(x,y) { return x / y; }

    // // 这里的函数以上面的某个函数作为参数
    // // 并给它传入两个操作数然后调用它
    // function operate(operator, operand1, operand2) {
    //     return operator(operand1, operand2)
    // }

    // // 这行代码所示的函数调用实际上计算 (2 + 3) + (a*5) 的值
    // var i = operate(add,operate(add,2,3), operate(multiply,4,5));


    // 我们为这个例子重复实现一个简单的函数
    // 这次实现使用函数直接量，这写函数直接量定义在一个对象直接量中
    // var operators = {
    //     add: function(x,y) {return x+y},
    //     subtract: function(x,y) {return x-y},
    //     multiply: function(x,y) {return x*y},
    //     divide: function(x,y) {return x/y},
    //     pow: Math.pow // 使用预定函数
    // }

    // // 这个函数接受一个名字作为运算符，在对象中查找这个运算符
    // // 然后将他作用与所提供的操作数
    // // 注意这里调用运算函数的语法
    // function operate2(operation, operand1,operand2) {
    //     console.log(operators);
    //     if(typeof operators[operation] === "function") {
    //         return operators[operation](operand1,operand2);
    //     } else {
    //         throw "unknow operator";
    //     }
    // }

    // // 这样来计算("hello" + "" + "world") 的值
    // var j = operate2("add","hellow",operate2("add", "", "world"))
    // // 使用预定义的函数 Math.pow();
    // var k = operate2("pow",10,2);
    // console.log(k);
    
    // 这行代码所示的函数调用实际上计算了

    // i 等于 （2+3）+（4*5）；


    // console.log(i);

    // // // 我们为这个重复实现一个简单的函数
    // // var operators = {
    // //     add: function(x,y){ return x + y};
    // // }

    // function funcl(a,b,c) {
    //     console.log(arguments);
    //     console.log(arguments[0] ===a);  // true

    // }

    // funcl(1,2,3,4);

    // let e = 5;
    // function func2(d, n = false) {

    //     d = 6;
    // }


    // var a = 1;
    // function fn() {
    //     var b = 2;
    //     function fn1() {
    //         console.log(b);//2       
    //         console.log(a);//1    
    //     }
    //     fn1();
    // }
    // fn();

    // function outer() {
    //     var a = '123'
    //     return function add() {　　　　  //在这里因为作用域的关系，add是能访问到outer的所有变量的，但是outer是访问不到add的变量；　　　　    
    //         console.log(a);             //所以思路一转，把add的值作为结果return出来变通实现outer外部函数访问到了内部函数变量 
    //     }                               // add就是一个闭包函数，因为他能够访问到outer函数的作用域，add中没有找到变量a，则会继续往上层作用域找    
    // }
    // var inner = outer()                 // 获得add闭包函数inner()   //"123"


    // console.log(func2(e));

    // function make_counter(){
    //     let count = 0;
    //     function inc_count(){
    //         count = count +1;
    //         return count;
    //     }
    // }
    // console.log(make_counter()); 
    // console.log(make_counter());

  






</script>



<head>
    <title>放置文章标题</title>
</head>

<body>

</body>

</html>